#include "bits/stdc++.h"
using namespace std;
// 状态码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
// #define INFEASIBLE -1
// #define OVERFLOW -2
typedef int status;
// 建立线性表（动态分配和静态分配）

// 静态线性表的最大长度和动态线性表的初始最大量
#define MAX_SIZE 10
#define maxinitSize 10 // 默认的最大容量

// 自定义数据元素的数据类型
typedef int Elemtype;
// 定义线性表的结构体（静态线性表）
typedef struct
{
    Elemtype data[MAX_SIZE];
    int length;
} Sqlist;
// 定义线性表的结构体（动态分配线性表）
typedef struct
{
    /*使用动态指针分配数组*/
    Elemtype *data;
    int length;
    int maxsize;
} Seqlist;

/*
    操作:各种实现功能
*/
// 静态顺序表的初始化
status InitSqlist(Sqlist &L)
{
    // 表长的初始化
    L.length = 0;
    return TRUE;
}
// 动态顺序表的初始化
status InitSeqlist(Seqlist &L)
{
    // 表长的初始化
    L.length = 0;
    // 动态分配存储空间
    L.data = (Elemtype *)malloc(sizeof(Elemtype) * maxinitSize);
    // c++: L.data=new Elemtype(maxinitSize);
    // 初始化最大的容量
    L.maxsize = maxinitSize;
    return TRUE;
}

// 静态顺序表的插入
status InsertSqlist(Sqlist &L, int i, Elemtype e)
{
    // 判断是否合法
    if (L.length >= MAX_SIZE || i <= 0 || i > L.length + 1)
    {

        cout << "不符合插入条件" << endl;
        return FALSE;
    }
    // 移动元素
    for (int pos = L.length; pos >= i; pos--)
    {
        L.data[pos] = L.data[pos - 1];
    }
    // 插入元素
    L.data[i - 1] = e;
    // 表长加1
    L.length += 1;
    return TRUE;
}
// 动态顺序表的插入
status InsertSeqlist(Seqlist &L, int i, Elemtype e)
{
    // 判断是否合法
    if (L.length >= L.maxsize || i <= 0 || i > L.length + 1)
    {

        cout << "不符合插入条件" << endl;
        return FALSE;
    }
    // 移动元素
    for (int pos = L.length; pos >= i; pos--)
    {
        L.data[pos] = L.data[pos - 1];
    }
    // 插入元素
    L.data[i - 1] = e;
    // 表长加1
    L.length += 1;
    return TRUE;
}

// 静态顺序表的查找(按值查找)
int LocatSqlist(Sqlist L, Elemtype e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i + 1;
        }
    }
    return FALSE;
}
// 动态顺序表的查找
int LocatSeqlist(Seqlist L, Elemtype e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i + 1;
        }
    }
    return FALSE;
}
// 静态顺序表的元素删除(按位删除)
Elemtype DeleteSqlist(Sqlist &L, int i)
{
    Elemtype e;
    if (i <= 0 || i > L.length)
    {
        return FALSE;
    }
    e = L.data[i - 1];
    for (int pos = i - 1; pos < L.length - 1; pos++)
    {
        L.data[pos] = L.data[pos + 1];
    }
    L.length -= 1;
    return e;
}
// 动态顺序表的元素删除(按位删除)
Elemtype DeleteSeqlist(Seqlist &L, int i)
{
    Elemtype e;
    if (i <= 0 || i > L.length)
    {
        return FALSE;
    }
    e = L.data[i - 1];
    for (int pos = i - 1; pos < L.length - 1; pos++)
    {
        L.data[pos] = L.data[pos + 1];
    }
    L.length -= 1;
    return e;
}

// 静态顺序表的输出
status sqListPrint(Sqlist L)
{
    if (L.length == 0)
    {
        cout << "该顺序表无元素" << endl;
        return FALSE;
    }
    // 输出顺序表的元素
    cout << "SqList: " << endl;
    for (int i = 0; i < L.length; i++)
    {
        cout << L.data[i] << "->";
    }
    cout << "end" << endl;
    return TRUE;
}

// 动态顺序表的输出
status SeqlistPrint(Seqlist L)
{
    if (L.length == 0)
    {
        cout << "该顺序表无元素" << endl;
        return FALSE;
    }
    cout << "Seqlist: " << endl;
    for (int i = 0; i < L.length; i++)
    {
        cout << L.data[i] << "->";
    }
    cout << "end";
    return TRUE;
}

int main()
{

    // 创建顺序表
    Sqlist list1;  // 静态顺序表
    Seqlist list2; // 动态顺序表

    list2.maxsize = 1;

    // 初始化
    InitSqlist(list1);
    InitSeqlist(list2);
    cout << "初始化后的最大容量: " << list2.maxsize << endl;

    InsertSqlist(list1, 1, 1);
    InsertSqlist(list1, 2, 2);
    InsertSqlist(list1, 3, 3);
    InsertSqlist(list1, 4, 4);
    InsertSqlist(list1, 5, 5);
    InsertSqlist(list1, 6, 6);
    InsertSqlist(list1, 7, 7);

    InsertSeqlist(list2, 1, 1);
    InsertSeqlist(list2, 2, 2);
    InsertSeqlist(list2, 3, 3);
    InsertSeqlist(list2, 4, 4);
    InsertSeqlist(list2, 5, 5);
    InsertSeqlist(list2, 6, 6);
    InsertSeqlist(list2, 7, 7);

    // 输出顺序表
    sqListPrint(list1);
    SeqlistPrint(list2);

    cout << "\n查找7元素的位置: " << LocatSqlist(list1, 7) << endl;

    cout << "查找5元素的位置: " << LocatSeqlist(list2, 5) << endl;

    // 删除元素的操作
    cout << "删除的元素为： " << DeleteSqlist(list1, 2) << endl;
    cout << "\n删除的元素为： " << DeleteSeqlist(list2, 3) << endl;

    cout << "\n现顺序表为: " << endl;
    sqListPrint(list1);
    SeqlistPrint(list2);
}